// Generated from D:/files/javaFiles/�����������/health-mgr-back/independent/src/main/java/com/xayy/health/core/antlr4/HealthEvaluate.g4 by ANTLR 4.13.1
package com.xayy.health.core.antlr4.parsing;

import java.util.List;

import org.antlr.v4.runtime.*;
import org.antlr.v4.runtime.atn.ATN;
import org.antlr.v4.runtime.atn.ATNDeserializer;
import org.antlr.v4.runtime.atn.ParserATNSimulator;
import org.antlr.v4.runtime.atn.PredictionContextCache;
import org.antlr.v4.runtime.dfa.DFA;
import org.antlr.v4.runtime.tree.ParseTreeListener;
import org.antlr.v4.runtime.tree.ParseTreeVisitor;
import org.antlr.v4.runtime.tree.TerminalNode;

@SuppressWarnings({"all", "warnings", "unchecked", "unused", "cast", "CheckReturnValue"})
public class HealthEvaluateParser extends Parser {
	static { RuntimeMetaData.checkVersion("4.13.1", RuntimeMetaData.VERSION); }

	protected static final DFA[] _decisionToDFA;
	protected static final PredictionContextCache _sharedContextCache =
		new PredictionContextCache();
	public static final int
		T__0=1, T__1=2, T__2=3, T__3=4, COMMENT=5, SL_COMMENT=6, WS=7, NEWLINE=8, 
		EQ=9, NEQ=10, LT=11, LE=12, GT=13, GE=14, AND=15, OR=16, MUL=17, DIV=18, 
		ADD=19, SUB=20, IF=21, ELIF=22, THEN=23, ELSE=24, SEMI=25, COMMA=26, DOT=27, 
		LBRACE=28, RBRACE=29, LPARENTHESE=30, RPARENTHESE=31, BOOL=32, NUMBER=33, 
		CHAR=34, ID=35, FUN=36, PARAM=37, XN=38, ABS=39;
	public static final int
		RULE_main = 0, RULE_command = 1, RULE_prog = 2, RULE_condition = 3, RULE_ifs = 4, 
		RULE_elif = 5, RULE_setArg = 6, RULE_compare = 7, RULE_expr = 8, RULE_fator = 9, 
		RULE_calcu = 10, RULE_abs = 11;
	private static String[] makeRuleNames() {
		return new String[] {
			"main", "command", "prog", "condition", "ifs", "elif", "setArg", "compare", 
			"expr", "fator", "calcu", "abs"
		};
	}
	public static final String[] ruleNames = makeRuleNames();

	private static String[] makeLiteralNames() {
		return new String[] {
			null, "'number'", "'='", "'string'", "'boolean'", null, null, null, null, 
			null, null, null, null, null, null, null, null, "'*'", "'/'", "'+'", 
			"'-'", "'if'", null, "'then'", "'else'", "';'", "','", "'.'", "'{'", 
			"'}'", "'('", "')'", null, null, null, null, "'function()'"
		};
	}
	private static final String[] _LITERAL_NAMES = makeLiteralNames();
	private static String[] makeSymbolicNames() {
		return new String[] {
			null, null, null, null, null, "COMMENT", "SL_COMMENT", "WS", "NEWLINE", 
			"EQ", "NEQ", "LT", "LE", "GT", "GE", "AND", "OR", "MUL", "DIV", "ADD", 
			"SUB", "IF", "ELIF", "THEN", "ELSE", "SEMI", "COMMA", "DOT", "LBRACE", 
			"RBRACE", "LPARENTHESE", "RPARENTHESE", "BOOL", "NUMBER", "CHAR", "ID", 
			"FUN", "PARAM", "XN", "ABS"
		};
	}
	private static final String[] _SYMBOLIC_NAMES = makeSymbolicNames();
	public static final Vocabulary VOCABULARY = new VocabularyImpl(_LITERAL_NAMES, _SYMBOLIC_NAMES);

	/**
	 * @deprecated Use {@link #VOCABULARY} instead.
	 */
	@Deprecated
	public static final String[] tokenNames;
	static {
		tokenNames = new String[_SYMBOLIC_NAMES.length];
		for (int i = 0; i < tokenNames.length; i++) {
			tokenNames[i] = VOCABULARY.getLiteralName(i);
			if (tokenNames[i] == null) {
				tokenNames[i] = VOCABULARY.getSymbolicName(i);
			}

			if (tokenNames[i] == null) {
				tokenNames[i] = "<INVALID>";
			}
		}
	}

	@Override
	@Deprecated
	public String[] getTokenNames() {
		return tokenNames;
	}

	@Override

	public Vocabulary getVocabulary() {
		return VOCABULARY;
	}

	@Override
	public String getGrammarFileName() { return "HealthEvaluate.g4"; }

	@Override
	public String[] getRuleNames() { return ruleNames; }

	@Override
	public String getSerializedATN() { return _serializedATN; }

	@Override
	public ATN getATN() { return _ATN; }

	public HealthEvaluateParser(TokenStream input) {
		super(input);
		_interp = new ParserATNSimulator(this,_ATN,_decisionToDFA,_sharedContextCache);
	}

	@SuppressWarnings("CheckReturnValue")
	public static class MainContext extends ParserRuleContext {
		public TerminalNode FUN() { return getToken(HealthEvaluateParser.FUN, 0); }
		public TerminalNode LBRACE() { return getToken(HealthEvaluateParser.LBRACE, 0); }
		public CommandContext command() {
			return getRuleContext(CommandContext.class,0);
		}
		public TerminalNode RBRACE() { return getToken(HealthEvaluateParser.RBRACE, 0); }
		public TerminalNode EOF() { return getToken(HealthEvaluateParser.EOF, 0); }
		public List<TerminalNode> NEWLINE() { return getTokens(HealthEvaluateParser.NEWLINE); }
		public TerminalNode NEWLINE(int i) {
			return getToken(HealthEvaluateParser.NEWLINE, i);
		}
		public MainContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_main; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof HealthEvaluateListener) ((HealthEvaluateListener)listener).enterMain(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof HealthEvaluateListener) ((HealthEvaluateListener)listener).exitMain(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof HealthEvaluateVisitor) return ((HealthEvaluateVisitor<? extends T>)visitor).visitMain(this);
			else return visitor.visitChildren(this);
		}
	}

	public final MainContext main() throws RecognitionException {
		MainContext _localctx = new MainContext(_ctx, getState());
		enterRule(_localctx, 0, RULE_main);
		int _la;
		try {
			int _alt;
			enterOuterAlt(_localctx, 1);
			{
			setState(24);
			match(FUN);
			setState(25);
			match(LBRACE);
			setState(29);
			_errHandler.sync(this);
			_alt = getInterpreter().adaptivePredict(_input,0,_ctx);
			while ( _alt!=2 && _alt!= ATN.INVALID_ALT_NUMBER ) {
				if ( _alt==1 ) {
					{
					{
					setState(26);
					match(NEWLINE);
					}
					} 
				}
				setState(31);
				_errHandler.sync(this);
				_alt = getInterpreter().adaptivePredict(_input,0,_ctx);
			}
			setState(32);
			command();
			setState(36);
			_errHandler.sync(this);
			_la = _input.LA(1);
			while (_la==NEWLINE) {
				{
				{
				setState(33);
				match(NEWLINE);
				}
				}
				setState(38);
				_errHandler.sync(this);
				_la = _input.LA(1);
			}
			setState(39);
			match(RBRACE);
			setState(40);
			match(EOF);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class CommandContext extends ParserRuleContext {
		public List<ProgContext> prog() {
			return getRuleContexts(ProgContext.class);
		}
		public ProgContext prog(int i) {
			return getRuleContext(ProgContext.class,i);
		}
		public List<TerminalNode> NEWLINE() { return getTokens(HealthEvaluateParser.NEWLINE); }
		public TerminalNode NEWLINE(int i) {
			return getToken(HealthEvaluateParser.NEWLINE, i);
		}
		public CommandContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_command; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof HealthEvaluateListener) ((HealthEvaluateListener)listener).enterCommand(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof HealthEvaluateListener) ((HealthEvaluateListener)listener).exitCommand(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof HealthEvaluateVisitor) return ((HealthEvaluateVisitor<? extends T>)visitor).visitCommand(this);
			else return visitor.visitChildren(this);
		}
	}

	public final CommandContext command() throws RecognitionException {
		CommandContext _localctx = new CommandContext(_ctx, getState());
		enterRule(_localctx, 2, RULE_command);
		try {
			int _alt;
			enterOuterAlt(_localctx, 1);
			{
			setState(46);
			_errHandler.sync(this);
			_alt = getInterpreter().adaptivePredict(_input,3,_ctx);
			while ( _alt!=2 && _alt!= ATN.INVALID_ALT_NUMBER ) {
				if ( _alt==1 ) {
					{
					setState(44);
					_errHandler.sync(this);
					switch (_input.LA(1)) {
					case T__0:
					case T__2:
					case T__3:
					case IF:
					case LPARENTHESE:
					case BOOL:
					case NUMBER:
					case PARAM:
					case XN:
					case ABS:
						{
						setState(42);
						prog();
						}
						break;
					case NEWLINE:
						{
						setState(43);
						match(NEWLINE);
						}
						break;
					default:
						throw new NoViableAltException(this);
					}
					} 
				}
				setState(48);
				_errHandler.sync(this);
				_alt = getInterpreter().adaptivePredict(_input,3,_ctx);
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class ProgContext extends ParserRuleContext {
		public List<CompareContext> compare() {
			return getRuleContexts(CompareContext.class);
		}
		public CompareContext compare(int i) {
			return getRuleContext(CompareContext.class,i);
		}
		public List<TerminalNode> SEMI() { return getTokens(HealthEvaluateParser.SEMI); }
		public TerminalNode SEMI(int i) {
			return getToken(HealthEvaluateParser.SEMI, i);
		}
		public List<TerminalNode> NEWLINE() { return getTokens(HealthEvaluateParser.NEWLINE); }
		public TerminalNode NEWLINE(int i) {
			return getToken(HealthEvaluateParser.NEWLINE, i);
		}
		public List<SetArgContext> setArg() {
			return getRuleContexts(SetArgContext.class);
		}
		public SetArgContext setArg(int i) {
			return getRuleContext(SetArgContext.class,i);
		}
		public List<ConditionContext> condition() {
			return getRuleContexts(ConditionContext.class);
		}
		public ConditionContext condition(int i) {
			return getRuleContext(ConditionContext.class,i);
		}
		public CalcuContext calcu() {
			return getRuleContext(CalcuContext.class,0);
		}
		public ProgContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_prog; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof HealthEvaluateListener) ((HealthEvaluateListener)listener).enterProg(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof HealthEvaluateListener) ((HealthEvaluateListener)listener).exitProg(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof HealthEvaluateVisitor) return ((HealthEvaluateVisitor<? extends T>)visitor).visitProg(this);
			else return visitor.visitChildren(this);
		}
	}

	public final ProgContext prog() throws RecognitionException {
		ProgContext _localctx = new ProgContext(_ctx, getState());
		enterRule(_localctx, 4, RULE_prog);
		int _la;
		try {
			int _alt;
			setState(69);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,7,_ctx) ) {
			case 1:
				enterOuterAlt(_localctx, 1);
				{
				setState(52); 
				_errHandler.sync(this);
				_alt = 1;
				do {
					switch (_alt) {
					case 1:
						{
						{
						setState(49);
						compare(0);
						setState(50);
						_la = _input.LA(1);
						if ( !(_la==NEWLINE || _la==SEMI) ) {
						_errHandler.recoverInline(this);
						}
						else {
							if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
							_errHandler.reportMatch(this);
							consume();
						}
						}
						}
						break;
					default:
						throw new NoViableAltException(this);
					}
					setState(54); 
					_errHandler.sync(this);
					_alt = getInterpreter().adaptivePredict(_input,4,_ctx);
				} while ( _alt!=2 && _alt!= ATN.INVALID_ALT_NUMBER );
				}
				break;
			case 2:
				enterOuterAlt(_localctx, 2);
				{
				setState(59); 
				_errHandler.sync(this);
				_alt = 1;
				do {
					switch (_alt) {
					case 1:
						{
						{
						setState(56);
						setArg();
						setState(57);
						_la = _input.LA(1);
						if ( !(_la==NEWLINE || _la==SEMI) ) {
						_errHandler.recoverInline(this);
						}
						else {
							if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
							_errHandler.reportMatch(this);
							consume();
						}
						}
						}
						break;
					default:
						throw new NoViableAltException(this);
					}
					setState(61); 
					_errHandler.sync(this);
					_alt = getInterpreter().adaptivePredict(_input,5,_ctx);
				} while ( _alt!=2 && _alt!= ATN.INVALID_ALT_NUMBER );
				}
				break;
			case 3:
				enterOuterAlt(_localctx, 3);
				{
				setState(64); 
				_errHandler.sync(this);
				_alt = 1;
				do {
					switch (_alt) {
					case 1:
						{
						{
						setState(63);
						condition();
						}
						}
						break;
					default:
						throw new NoViableAltException(this);
					}
					setState(66); 
					_errHandler.sync(this);
					_alt = getInterpreter().adaptivePredict(_input,6,_ctx);
				} while ( _alt!=2 && _alt!= ATN.INVALID_ALT_NUMBER );
				}
				break;
			case 4:
				enterOuterAlt(_localctx, 4);
				{
				setState(68);
				calcu(0);
				}
				break;
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class ConditionContext extends ParserRuleContext {
		public CommandContext ifblock;
		public CommandContext elseblock;
		public IfsContext ifs() {
			return getRuleContext(IfsContext.class,0);
		}
		public List<TerminalNode> LBRACE() { return getTokens(HealthEvaluateParser.LBRACE); }
		public TerminalNode LBRACE(int i) {
			return getToken(HealthEvaluateParser.LBRACE, i);
		}
		public List<TerminalNode> RBRACE() { return getTokens(HealthEvaluateParser.RBRACE); }
		public TerminalNode RBRACE(int i) {
			return getToken(HealthEvaluateParser.RBRACE, i);
		}
		public List<CommandContext> command() {
			return getRuleContexts(CommandContext.class);
		}
		public CommandContext command(int i) {
			return getRuleContext(CommandContext.class,i);
		}
		public List<ElifContext> elif() {
			return getRuleContexts(ElifContext.class);
		}
		public ElifContext elif(int i) {
			return getRuleContext(ElifContext.class,i);
		}
		public TerminalNode ELSE() { return getToken(HealthEvaluateParser.ELSE, 0); }
		public ConditionContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_condition; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof HealthEvaluateListener) ((HealthEvaluateListener)listener).enterCondition(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof HealthEvaluateListener) ((HealthEvaluateListener)listener).exitCondition(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof HealthEvaluateVisitor) return ((HealthEvaluateVisitor<? extends T>)visitor).visitCondition(this);
			else return visitor.visitChildren(this);
		}
	}

	public final ConditionContext condition() throws RecognitionException {
		ConditionContext _localctx = new ConditionContext(_ctx, getState());
		enterRule(_localctx, 6, RULE_condition);
		int _la;
		try {
			int _alt;
			enterOuterAlt(_localctx, 1);
			{
			setState(71);
			ifs();
			setState(72);
			match(LBRACE);
			setState(73);
			((ConditionContext)_localctx).ifblock = command();
			setState(74);
			match(RBRACE);
			setState(82);
			_errHandler.sync(this);
			_alt = getInterpreter().adaptivePredict(_input,8,_ctx);
			while ( _alt!=1 && _alt!= ATN.INVALID_ALT_NUMBER ) {
				if ( _alt==1+1 ) {
					{
					{
					setState(75);
					elif();
					setState(76);
					match(LBRACE);
					setState(77);
					command();
					setState(78);
					match(RBRACE);
					}
					} 
				}
				setState(84);
				_errHandler.sync(this);
				_alt = getInterpreter().adaptivePredict(_input,8,_ctx);
			}
			setState(90);
			_errHandler.sync(this);
			_la = _input.LA(1);
			if (_la==ELSE) {
				{
				setState(85);
				match(ELSE);
				setState(86);
				match(LBRACE);
				setState(87);
				((ConditionContext)_localctx).elseblock = command();
				setState(88);
				match(RBRACE);
				}
			}

			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class IfsContext extends ParserRuleContext {
		public TerminalNode IF() { return getToken(HealthEvaluateParser.IF, 0); }
		public CompareContext compare() {
			return getRuleContext(CompareContext.class,0);
		}
		public TerminalNode LPARENTHESE() { return getToken(HealthEvaluateParser.LPARENTHESE, 0); }
		public TerminalNode RPARENTHESE() { return getToken(HealthEvaluateParser.RPARENTHESE, 0); }
		public IfsContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_ifs; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof HealthEvaluateListener) ((HealthEvaluateListener)listener).enterIfs(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof HealthEvaluateListener) ((HealthEvaluateListener)listener).exitIfs(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof HealthEvaluateVisitor) return ((HealthEvaluateVisitor<? extends T>)visitor).visitIfs(this);
			else return visitor.visitChildren(this);
		}
	}

	public final IfsContext ifs() throws RecognitionException {
		IfsContext _localctx = new IfsContext(_ctx, getState());
		enterRule(_localctx, 8, RULE_ifs);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(92);
			match(IF);
			setState(94);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,10,_ctx) ) {
			case 1:
				{
				setState(93);
				match(LPARENTHESE);
				}
				break;
			}
			setState(96);
			compare(0);
			setState(98);
			_errHandler.sync(this);
			_la = _input.LA(1);
			if (_la==RPARENTHESE) {
				{
				setState(97);
				match(RPARENTHESE);
				}
			}

			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class ElifContext extends ParserRuleContext {
		public TerminalNode ELIF() { return getToken(HealthEvaluateParser.ELIF, 0); }
		public CompareContext compare() {
			return getRuleContext(CompareContext.class,0);
		}
		public TerminalNode LPARENTHESE() { return getToken(HealthEvaluateParser.LPARENTHESE, 0); }
		public TerminalNode RPARENTHESE() { return getToken(HealthEvaluateParser.RPARENTHESE, 0); }
		public ElifContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_elif; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof HealthEvaluateListener) ((HealthEvaluateListener)listener).enterElif(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof HealthEvaluateListener) ((HealthEvaluateListener)listener).exitElif(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof HealthEvaluateVisitor) return ((HealthEvaluateVisitor<? extends T>)visitor).visitElif(this);
			else return visitor.visitChildren(this);
		}
	}

	public final ElifContext elif() throws RecognitionException {
		ElifContext _localctx = new ElifContext(_ctx, getState());
		enterRule(_localctx, 10, RULE_elif);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(100);
			match(ELIF);
			setState(102);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,12,_ctx) ) {
			case 1:
				{
				setState(101);
				match(LPARENTHESE);
				}
				break;
			}
			setState(104);
			compare(0);
			setState(106);
			_errHandler.sync(this);
			_la = _input.LA(1);
			if (_la==RPARENTHESE) {
				{
				setState(105);
				match(RPARENTHESE);
				}
			}

			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class SetArgContext extends ParserRuleContext {
		public SetArgContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_setArg; }
	 
		public SetArgContext() { }
		public void copyFrom(SetArgContext ctx) {
			super.copyFrom(ctx);
		}
	}
	@SuppressWarnings("CheckReturnValue")
	public static class BoolargContext extends SetArgContext {
		public Token id;
		public CompareContext compare() {
			return getRuleContext(CompareContext.class,0);
		}
		public TerminalNode ID() { return getToken(HealthEvaluateParser.ID, 0); }
		public BoolargContext(SetArgContext ctx) { copyFrom(ctx); }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof HealthEvaluateListener) ((HealthEvaluateListener)listener).enterBoolarg(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof HealthEvaluateListener) ((HealthEvaluateListener)listener).exitBoolarg(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof HealthEvaluateVisitor) return ((HealthEvaluateVisitor<? extends T>)visitor).visitBoolarg(this);
			else return visitor.visitChildren(this);
		}
	}
	@SuppressWarnings("CheckReturnValue")
	public static class NumargContext extends SetArgContext {
		public Token id;
		public CalcuContext calcu() {
			return getRuleContext(CalcuContext.class,0);
		}
		public TerminalNode ID() { return getToken(HealthEvaluateParser.ID, 0); }
		public NumargContext(SetArgContext ctx) { copyFrom(ctx); }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof HealthEvaluateListener) ((HealthEvaluateListener)listener).enterNumarg(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof HealthEvaluateListener) ((HealthEvaluateListener)listener).exitNumarg(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof HealthEvaluateVisitor) return ((HealthEvaluateVisitor<? extends T>)visitor).visitNumarg(this);
			else return visitor.visitChildren(this);
		}
	}
	@SuppressWarnings("CheckReturnValue")
	public static class CharargContext extends SetArgContext {
		public Token id;
		public Token value;
		public TerminalNode ID() { return getToken(HealthEvaluateParser.ID, 0); }
		public TerminalNode CHAR() { return getToken(HealthEvaluateParser.CHAR, 0); }
		public CharargContext(SetArgContext ctx) { copyFrom(ctx); }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof HealthEvaluateListener) ((HealthEvaluateListener)listener).enterChararg(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof HealthEvaluateListener) ((HealthEvaluateListener)listener).exitChararg(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof HealthEvaluateVisitor) return ((HealthEvaluateVisitor<? extends T>)visitor).visitChararg(this);
			else return visitor.visitChildren(this);
		}
	}

	public final SetArgContext setArg() throws RecognitionException {
		SetArgContext _localctx = new SetArgContext(_ctx, getState());
		enterRule(_localctx, 12, RULE_setArg);
		try {
			setState(120);
			_errHandler.sync(this);
			switch (_input.LA(1)) {
			case T__0:
				_localctx = new NumargContext(_localctx);
				enterOuterAlt(_localctx, 1);
				{
				setState(108);
				match(T__0);
				setState(109);
				((NumargContext)_localctx).id = match(ID);
				setState(110);
				match(T__1);
				setState(111);
				calcu(0);
				}
				break;
			case T__2:
				_localctx = new CharargContext(_localctx);
				enterOuterAlt(_localctx, 2);
				{
				setState(112);
				match(T__2);
				setState(113);
				((CharargContext)_localctx).id = match(ID);
				setState(114);
				match(T__1);
				setState(115);
				((CharargContext)_localctx).value = match(CHAR);
				}
				break;
			case T__3:
				_localctx = new BoolargContext(_localctx);
				enterOuterAlt(_localctx, 3);
				{
				setState(116);
				match(T__3);
				setState(117);
				((BoolargContext)_localctx).id = match(ID);
				setState(118);
				match(T__1);
				setState(119);
				compare(0);
				}
				break;
			default:
				throw new NoViableAltException(this);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class CompareContext extends ParserRuleContext {
		public CompareContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_compare; }
	 
		public CompareContext() { }
		public void copyFrom(CompareContext ctx) {
			super.copyFrom(ctx);
		}
	}
	@SuppressWarnings("CheckReturnValue")
	public static class OrContext extends CompareContext {
		public List<CompareContext> compare() {
			return getRuleContexts(CompareContext.class);
		}
		public CompareContext compare(int i) {
			return getRuleContext(CompareContext.class,i);
		}
		public TerminalNode OR() { return getToken(HealthEvaluateParser.OR, 0); }
		public OrContext(CompareContext ctx) { copyFrom(ctx); }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof HealthEvaluateListener) ((HealthEvaluateListener)listener).enterOr(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof HealthEvaluateListener) ((HealthEvaluateListener)listener).exitOr(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof HealthEvaluateVisitor) return ((HealthEvaluateVisitor<? extends T>)visitor).visitOr(this);
			else return visitor.visitChildren(this);
		}
	}
	@SuppressWarnings("CheckReturnValue")
	public static class BoolContext extends CompareContext {
		public TerminalNode BOOL() { return getToken(HealthEvaluateParser.BOOL, 0); }
		public BoolContext(CompareContext ctx) { copyFrom(ctx); }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof HealthEvaluateListener) ((HealthEvaluateListener)listener).enterBool(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof HealthEvaluateListener) ((HealthEvaluateListener)listener).exitBool(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof HealthEvaluateVisitor) return ((HealthEvaluateVisitor<? extends T>)visitor).visitBool(this);
			else return visitor.visitChildren(this);
		}
	}
	@SuppressWarnings("CheckReturnValue")
	public static class AndContext extends CompareContext {
		public List<CompareContext> compare() {
			return getRuleContexts(CompareContext.class);
		}
		public CompareContext compare(int i) {
			return getRuleContext(CompareContext.class,i);
		}
		public TerminalNode AND() { return getToken(HealthEvaluateParser.AND, 0); }
		public AndContext(CompareContext ctx) { copyFrom(ctx); }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof HealthEvaluateListener) ((HealthEvaluateListener)listener).enterAnd(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof HealthEvaluateListener) ((HealthEvaluateListener)listener).exitAnd(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof HealthEvaluateVisitor) return ((HealthEvaluateVisitor<? extends T>)visitor).visitAnd(this);
			else return visitor.visitChildren(this);
		}
	}
	@SuppressWarnings("CheckReturnValue")
	public static class ExreContext extends CompareContext {
		public ExprContext expr() {
			return getRuleContext(ExprContext.class,0);
		}
		public ExreContext(CompareContext ctx) { copyFrom(ctx); }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof HealthEvaluateListener) ((HealthEvaluateListener)listener).enterExre(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof HealthEvaluateListener) ((HealthEvaluateListener)listener).exitExre(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof HealthEvaluateVisitor) return ((HealthEvaluateVisitor<? extends T>)visitor).visitExre(this);
			else return visitor.visitChildren(this);
		}
	}

	public final CompareContext compare() throws RecognitionException {
		return compare(0);
	}

	private CompareContext compare(int _p) throws RecognitionException {
		ParserRuleContext _parentctx = _ctx;
		int _parentState = getState();
		CompareContext _localctx = new CompareContext(_ctx, _parentState);
		CompareContext _prevctx = _localctx;
		int _startState = 14;
		enterRecursionRule(_localctx, 14, RULE_compare, _p);
		try {
			int _alt;
			enterOuterAlt(_localctx, 1);
			{
			setState(125);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,15,_ctx) ) {
			case 1:
				{
				_localctx = new ExreContext(_localctx);
				_ctx = _localctx;
				_prevctx = _localctx;

				setState(123);
				expr();
				}
				break;
			case 2:
				{
				_localctx = new BoolContext(_localctx);
				_ctx = _localctx;
				_prevctx = _localctx;
				setState(124);
				match(BOOL);
				}
				break;
			}
			_ctx.stop = _input.LT(-1);
			setState(135);
			_errHandler.sync(this);
			_alt = getInterpreter().adaptivePredict(_input,17,_ctx);
			while ( _alt!=2 && _alt!= ATN.INVALID_ALT_NUMBER ) {
				if ( _alt==1 ) {
					if ( _parseListeners!=null ) triggerExitRuleEvent();
					_prevctx = _localctx;
					{
					setState(133);
					_errHandler.sync(this);
					switch ( getInterpreter().adaptivePredict(_input,16,_ctx) ) {
					case 1:
						{
						_localctx = new AndContext(new CompareContext(_parentctx, _parentState));
						pushNewRecursionContext(_localctx, _startState, RULE_compare);
						setState(127);
						if (!(precpred(_ctx, 4))) throw new FailedPredicateException(this, "precpred(_ctx, 4)");
						setState(128);
						match(AND);
						setState(129);
						compare(5);
						}
						break;
					case 2:
						{
						_localctx = new OrContext(new CompareContext(_parentctx, _parentState));
						pushNewRecursionContext(_localctx, _startState, RULE_compare);
						setState(130);
						if (!(precpred(_ctx, 3))) throw new FailedPredicateException(this, "precpred(_ctx, 3)");
						setState(131);
						match(OR);
						setState(132);
						compare(4);
						}
						break;
					}
					} 
				}
				setState(137);
				_errHandler.sync(this);
				_alt = getInterpreter().adaptivePredict(_input,17,_ctx);
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			unrollRecursionContexts(_parentctx);
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class ExprContext extends ParserRuleContext {
		public ExprContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_expr; }
	 
		public ExprContext() { }
		public void copyFrom(ExprContext ctx) {
			super.copyFrom(ctx);
		}
	}
	@SuppressWarnings("CheckReturnValue")
	public static class LtContext extends ExprContext {
		public List<FatorContext> fator() {
			return getRuleContexts(FatorContext.class);
		}
		public FatorContext fator(int i) {
			return getRuleContext(FatorContext.class,i);
		}
		public TerminalNode LT() { return getToken(HealthEvaluateParser.LT, 0); }
		public LtContext(ExprContext ctx) { copyFrom(ctx); }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof HealthEvaluateListener) ((HealthEvaluateListener)listener).enterLt(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof HealthEvaluateListener) ((HealthEvaluateListener)listener).exitLt(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof HealthEvaluateVisitor) return ((HealthEvaluateVisitor<? extends T>)visitor).visitLt(this);
			else return visitor.visitChildren(this);
		}
	}
	@SuppressWarnings("CheckReturnValue")
	public static class LeContext extends ExprContext {
		public List<FatorContext> fator() {
			return getRuleContexts(FatorContext.class);
		}
		public FatorContext fator(int i) {
			return getRuleContext(FatorContext.class,i);
		}
		public TerminalNode LE() { return getToken(HealthEvaluateParser.LE, 0); }
		public LeContext(ExprContext ctx) { copyFrom(ctx); }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof HealthEvaluateListener) ((HealthEvaluateListener)listener).enterLe(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof HealthEvaluateListener) ((HealthEvaluateListener)listener).exitLe(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof HealthEvaluateVisitor) return ((HealthEvaluateVisitor<? extends T>)visitor).visitLe(this);
			else return visitor.visitChildren(this);
		}
	}
	@SuppressWarnings("CheckReturnValue")
	public static class DoubleSymbolContext extends ExprContext {
		public Token operatorL;
		public Token operatorR;
		public List<FatorContext> fator() {
			return getRuleContexts(FatorContext.class);
		}
		public FatorContext fator(int i) {
			return getRuleContext(FatorContext.class,i);
		}
		public List<TerminalNode> EQ() { return getTokens(HealthEvaluateParser.EQ); }
		public TerminalNode EQ(int i) {
			return getToken(HealthEvaluateParser.EQ, i);
		}
		public List<TerminalNode> NEQ() { return getTokens(HealthEvaluateParser.NEQ); }
		public TerminalNode NEQ(int i) {
			return getToken(HealthEvaluateParser.NEQ, i);
		}
		public List<TerminalNode> LT() { return getTokens(HealthEvaluateParser.LT); }
		public TerminalNode LT(int i) {
			return getToken(HealthEvaluateParser.LT, i);
		}
		public List<TerminalNode> LE() { return getTokens(HealthEvaluateParser.LE); }
		public TerminalNode LE(int i) {
			return getToken(HealthEvaluateParser.LE, i);
		}
		public List<TerminalNode> GT() { return getTokens(HealthEvaluateParser.GT); }
		public TerminalNode GT(int i) {
			return getToken(HealthEvaluateParser.GT, i);
		}
		public List<TerminalNode> GE() { return getTokens(HealthEvaluateParser.GE); }
		public TerminalNode GE(int i) {
			return getToken(HealthEvaluateParser.GE, i);
		}
		public DoubleSymbolContext(ExprContext ctx) { copyFrom(ctx); }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof HealthEvaluateListener) ((HealthEvaluateListener)listener).enterDoubleSymbol(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof HealthEvaluateListener) ((HealthEvaluateListener)listener).exitDoubleSymbol(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof HealthEvaluateVisitor) return ((HealthEvaluateVisitor<? extends T>)visitor).visitDoubleSymbol(this);
			else return visitor.visitChildren(this);
		}
	}
	@SuppressWarnings("CheckReturnValue")
	public static class EqContext extends ExprContext {
		public List<FatorContext> fator() {
			return getRuleContexts(FatorContext.class);
		}
		public FatorContext fator(int i) {
			return getRuleContext(FatorContext.class,i);
		}
		public TerminalNode EQ() { return getToken(HealthEvaluateParser.EQ, 0); }
		public EqContext(ExprContext ctx) { copyFrom(ctx); }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof HealthEvaluateListener) ((HealthEvaluateListener)listener).enterEq(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof HealthEvaluateListener) ((HealthEvaluateListener)listener).exitEq(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof HealthEvaluateVisitor) return ((HealthEvaluateVisitor<? extends T>)visitor).visitEq(this);
			else return visitor.visitChildren(this);
		}
	}
	@SuppressWarnings("CheckReturnValue")
	public static class NoteqContext extends ExprContext {
		public List<FatorContext> fator() {
			return getRuleContexts(FatorContext.class);
		}
		public FatorContext fator(int i) {
			return getRuleContext(FatorContext.class,i);
		}
		public TerminalNode NEQ() { return getToken(HealthEvaluateParser.NEQ, 0); }
		public NoteqContext(ExprContext ctx) { copyFrom(ctx); }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof HealthEvaluateListener) ((HealthEvaluateListener)listener).enterNoteq(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof HealthEvaluateListener) ((HealthEvaluateListener)listener).exitNoteq(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof HealthEvaluateVisitor) return ((HealthEvaluateVisitor<? extends T>)visitor).visitNoteq(this);
			else return visitor.visitChildren(this);
		}
	}
	@SuppressWarnings("CheckReturnValue")
	public static class GtContext extends ExprContext {
		public List<FatorContext> fator() {
			return getRuleContexts(FatorContext.class);
		}
		public FatorContext fator(int i) {
			return getRuleContext(FatorContext.class,i);
		}
		public TerminalNode GT() { return getToken(HealthEvaluateParser.GT, 0); }
		public GtContext(ExprContext ctx) { copyFrom(ctx); }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof HealthEvaluateListener) ((HealthEvaluateListener)listener).enterGt(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof HealthEvaluateListener) ((HealthEvaluateListener)listener).exitGt(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof HealthEvaluateVisitor) return ((HealthEvaluateVisitor<? extends T>)visitor).visitGt(this);
			else return visitor.visitChildren(this);
		}
	}
	@SuppressWarnings("CheckReturnValue")
	public static class GeContext extends ExprContext {
		public List<FatorContext> fator() {
			return getRuleContexts(FatorContext.class);
		}
		public FatorContext fator(int i) {
			return getRuleContext(FatorContext.class,i);
		}
		public TerminalNode GE() { return getToken(HealthEvaluateParser.GE, 0); }
		public GeContext(ExprContext ctx) { copyFrom(ctx); }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof HealthEvaluateListener) ((HealthEvaluateListener)listener).enterGe(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof HealthEvaluateListener) ((HealthEvaluateListener)listener).exitGe(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof HealthEvaluateVisitor) return ((HealthEvaluateVisitor<? extends T>)visitor).visitGe(this);
			else return visitor.visitChildren(this);
		}
	}

	public final ExprContext expr() throws RecognitionException {
		ExprContext _localctx = new ExprContext(_ctx, getState());
		enterRule(_localctx, 16, RULE_expr);
		int _la;
		try {
			setState(168);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,18,_ctx) ) {
			case 1:
				_localctx = new DoubleSymbolContext(_localctx);
				enterOuterAlt(_localctx, 1);
				{
				setState(138);
				fator();
				setState(139);
				((DoubleSymbolContext)_localctx).operatorL = _input.LT(1);
				_la = _input.LA(1);
				if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & 32256L) != 0)) ) {
					((DoubleSymbolContext)_localctx).operatorL = (Token)_errHandler.recoverInline(this);
				}
				else {
					if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
					_errHandler.reportMatch(this);
					consume();
				}
				setState(140);
				fator();
				setState(141);
				((DoubleSymbolContext)_localctx).operatorR = _input.LT(1);
				_la = _input.LA(1);
				if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & 32256L) != 0)) ) {
					((DoubleSymbolContext)_localctx).operatorR = (Token)_errHandler.recoverInline(this);
				}
				else {
					if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
					_errHandler.reportMatch(this);
					consume();
				}
				setState(142);
				fator();
				}
				break;
			case 2:
				_localctx = new EqContext(_localctx);
				enterOuterAlt(_localctx, 2);
				{
				setState(144);
				fator();
				setState(145);
				match(EQ);
				setState(146);
				fator();
				}
				break;
			case 3:
				_localctx = new NoteqContext(_localctx);
				enterOuterAlt(_localctx, 3);
				{
				setState(148);
				fator();
				setState(149);
				match(NEQ);
				setState(150);
				fator();
				}
				break;
			case 4:
				_localctx = new LtContext(_localctx);
				enterOuterAlt(_localctx, 4);
				{
				setState(152);
				fator();
				setState(153);
				match(LT);
				setState(154);
				fator();
				}
				break;
			case 5:
				_localctx = new LeContext(_localctx);
				enterOuterAlt(_localctx, 5);
				{
				setState(156);
				fator();
				setState(157);
				match(LE);
				setState(158);
				fator();
				}
				break;
			case 6:
				_localctx = new GtContext(_localctx);
				enterOuterAlt(_localctx, 6);
				{
				setState(160);
				fator();
				setState(161);
				match(GT);
				setState(162);
				fator();
				}
				break;
			case 7:
				_localctx = new GeContext(_localctx);
				enterOuterAlt(_localctx, 7);
				{
				setState(164);
				fator();
				setState(165);
				match(GE);
				setState(166);
				fator();
				}
				break;
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class FatorContext extends ParserRuleContext {
		public FatorContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_fator; }
	 
		public FatorContext() { }
		public void copyFrom(FatorContext ctx) {
			super.copyFrom(ctx);
		}
	}
	@SuppressWarnings("CheckReturnValue")
	public static class FatorExprContext extends FatorContext {
		public TerminalNode LPARENTHESE() { return getToken(HealthEvaluateParser.LPARENTHESE, 0); }
		public ExprContext expr() {
			return getRuleContext(ExprContext.class,0);
		}
		public TerminalNode RPARENTHESE() { return getToken(HealthEvaluateParser.RPARENTHESE, 0); }
		public FatorExprContext(FatorContext ctx) { copyFrom(ctx); }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof HealthEvaluateListener) ((HealthEvaluateListener)listener).enterFatorExpr(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof HealthEvaluateListener) ((HealthEvaluateListener)listener).exitFatorExpr(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof HealthEvaluateVisitor) return ((HealthEvaluateVisitor<? extends T>)visitor).visitFatorExpr(this);
			else return visitor.visitChildren(this);
		}
	}
	@SuppressWarnings("CheckReturnValue")
	public static class FatorParamContext extends FatorContext {
		public CalcuContext calcu() {
			return getRuleContext(CalcuContext.class,0);
		}
		public FatorParamContext(FatorContext ctx) { copyFrom(ctx); }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof HealthEvaluateListener) ((HealthEvaluateListener)listener).enterFatorParam(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof HealthEvaluateListener) ((HealthEvaluateListener)listener).exitFatorParam(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof HealthEvaluateVisitor) return ((HealthEvaluateVisitor<? extends T>)visitor).visitFatorParam(this);
			else return visitor.visitChildren(this);
		}
	}
	@SuppressWarnings("CheckReturnValue")
	public static class FatorBoolContext extends FatorContext {
		public TerminalNode BOOL() { return getToken(HealthEvaluateParser.BOOL, 0); }
		public FatorBoolContext(FatorContext ctx) { copyFrom(ctx); }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof HealthEvaluateListener) ((HealthEvaluateListener)listener).enterFatorBool(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof HealthEvaluateListener) ((HealthEvaluateListener)listener).exitFatorBool(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof HealthEvaluateVisitor) return ((HealthEvaluateVisitor<? extends T>)visitor).visitFatorBool(this);
			else return visitor.visitChildren(this);
		}
	}

	public final FatorContext fator() throws RecognitionException {
		FatorContext _localctx = new FatorContext(_ctx, getState());
		enterRule(_localctx, 18, RULE_fator);
		try {
			setState(176);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,19,_ctx) ) {
			case 1:
				_localctx = new FatorExprContext(_localctx);
				enterOuterAlt(_localctx, 1);
				{
				setState(170);
				match(LPARENTHESE);
				setState(171);
				expr();
				setState(172);
				match(RPARENTHESE);
				}
				break;
			case 2:
				_localctx = new FatorParamContext(_localctx);
				enterOuterAlt(_localctx, 2);
				{
				setState(174);
				calcu(0);
				}
				break;
			case 3:
				_localctx = new FatorBoolContext(_localctx);
				enterOuterAlt(_localctx, 3);
				{
				setState(175);
				match(BOOL);
				}
				break;
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class CalcuContext extends ParserRuleContext {
		public CalcuContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_calcu; }
	 
		public CalcuContext() { }
		public void copyFrom(CalcuContext ctx) {
			super.copyFrom(ctx);
		}
	}
	@SuppressWarnings("CheckReturnValue")
	public static class AddAndSubContext extends CalcuContext {
		public Token opt;
		public List<CalcuContext> calcu() {
			return getRuleContexts(CalcuContext.class);
		}
		public CalcuContext calcu(int i) {
			return getRuleContext(CalcuContext.class,i);
		}
		public TerminalNode ADD() { return getToken(HealthEvaluateParser.ADD, 0); }
		public TerminalNode SUB() { return getToken(HealthEvaluateParser.SUB, 0); }
		public AddAndSubContext(CalcuContext ctx) { copyFrom(ctx); }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof HealthEvaluateListener) ((HealthEvaluateListener)listener).enterAddAndSub(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof HealthEvaluateListener) ((HealthEvaluateListener)listener).exitAddAndSub(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof HealthEvaluateVisitor) return ((HealthEvaluateVisitor<? extends T>)visitor).visitAddAndSub(this);
			else return visitor.visitChildren(this);
		}
	}
	@SuppressWarnings("CheckReturnValue")
	public static class NumberContext extends CalcuContext {
		public TerminalNode NUMBER() { return getToken(HealthEvaluateParser.NUMBER, 0); }
		public NumberContext(CalcuContext ctx) { copyFrom(ctx); }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof HealthEvaluateListener) ((HealthEvaluateListener)listener).enterNumber(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof HealthEvaluateListener) ((HealthEvaluateListener)listener).exitNumber(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof HealthEvaluateVisitor) return ((HealthEvaluateVisitor<? extends T>)visitor).visitNumber(this);
			else return visitor.visitChildren(this);
		}
	}
	@SuppressWarnings("CheckReturnValue")
	public static class TandemLeftContext extends CalcuContext {
		public List<CalcuContext> calcu() {
			return getRuleContexts(CalcuContext.class);
		}
		public CalcuContext calcu(int i) {
			return getRuleContext(CalcuContext.class,i);
		}
		public TerminalNode LPARENTHESE() { return getToken(HealthEvaluateParser.LPARENTHESE, 0); }
		public TandemLeftContext(CalcuContext ctx) { copyFrom(ctx); }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof HealthEvaluateListener) ((HealthEvaluateListener)listener).enterTandemLeft(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof HealthEvaluateListener) ((HealthEvaluateListener)listener).exitTandemLeft(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof HealthEvaluateVisitor) return ((HealthEvaluateVisitor<? extends T>)visitor).visitTandemLeft(this);
			else return visitor.visitChildren(this);
		}
	}
	@SuppressWarnings("CheckReturnValue")
	public static class ParensContext extends CalcuContext {
		public TerminalNode LPARENTHESE() { return getToken(HealthEvaluateParser.LPARENTHESE, 0); }
		public CalcuContext calcu() {
			return getRuleContext(CalcuContext.class,0);
		}
		public TerminalNode RPARENTHESE() { return getToken(HealthEvaluateParser.RPARENTHESE, 0); }
		public ParensContext(CalcuContext ctx) { copyFrom(ctx); }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof HealthEvaluateListener) ((HealthEvaluateListener)listener).enterParens(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof HealthEvaluateListener) ((HealthEvaluateListener)listener).exitParens(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof HealthEvaluateVisitor) return ((HealthEvaluateVisitor<? extends T>)visitor).visitParens(this);
			else return visitor.visitChildren(this);
		}
	}
	@SuppressWarnings("CheckReturnValue")
	public static class ParamContext extends CalcuContext {
		public TerminalNode PARAM() { return getToken(HealthEvaluateParser.PARAM, 0); }
		public ParamContext(CalcuContext ctx) { copyFrom(ctx); }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof HealthEvaluateListener) ((HealthEvaluateListener)listener).enterParam(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof HealthEvaluateListener) ((HealthEvaluateListener)listener).exitParam(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof HealthEvaluateVisitor) return ((HealthEvaluateVisitor<? extends T>)visitor).visitParam(this);
			else return visitor.visitChildren(this);
		}
	}
	@SuppressWarnings("CheckReturnValue")
	public static class XnContext extends CalcuContext {
		public TerminalNode XN() { return getToken(HealthEvaluateParser.XN, 0); }
		public XnContext(CalcuContext ctx) { copyFrom(ctx); }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof HealthEvaluateListener) ((HealthEvaluateListener)listener).enterXn(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof HealthEvaluateListener) ((HealthEvaluateListener)listener).exitXn(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof HealthEvaluateVisitor) return ((HealthEvaluateVisitor<? extends T>)visitor).visitXn(this);
			else return visitor.visitChildren(this);
		}
	}
	@SuppressWarnings("CheckReturnValue")
	public static class CalcuAbsContext extends CalcuContext {
		public AbsContext abs() {
			return getRuleContext(AbsContext.class,0);
		}
		public CalcuAbsContext(CalcuContext ctx) { copyFrom(ctx); }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof HealthEvaluateListener) ((HealthEvaluateListener)listener).enterCalcuAbs(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof HealthEvaluateListener) ((HealthEvaluateListener)listener).exitCalcuAbs(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof HealthEvaluateVisitor) return ((HealthEvaluateVisitor<? extends T>)visitor).visitCalcuAbs(this);
			else return visitor.visitChildren(this);
		}
	}
	@SuppressWarnings("CheckReturnValue")
	public static class MulAndDivContext extends CalcuContext {
		public Token opt;
		public List<CalcuContext> calcu() {
			return getRuleContexts(CalcuContext.class);
		}
		public CalcuContext calcu(int i) {
			return getRuleContext(CalcuContext.class,i);
		}
		public TerminalNode MUL() { return getToken(HealthEvaluateParser.MUL, 0); }
		public TerminalNode DIV() { return getToken(HealthEvaluateParser.DIV, 0); }
		public MulAndDivContext(CalcuContext ctx) { copyFrom(ctx); }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof HealthEvaluateListener) ((HealthEvaluateListener)listener).enterMulAndDiv(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof HealthEvaluateListener) ((HealthEvaluateListener)listener).exitMulAndDiv(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof HealthEvaluateVisitor) return ((HealthEvaluateVisitor<? extends T>)visitor).visitMulAndDiv(this);
			else return visitor.visitChildren(this);
		}
	}
	@SuppressWarnings("CheckReturnValue")
	public static class TandemRightContext extends CalcuContext {
		public List<CalcuContext> calcu() {
			return getRuleContexts(CalcuContext.class);
		}
		public CalcuContext calcu(int i) {
			return getRuleContext(CalcuContext.class,i);
		}
		public TerminalNode RPARENTHESE() { return getToken(HealthEvaluateParser.RPARENTHESE, 0); }
		public TandemRightContext(CalcuContext ctx) { copyFrom(ctx); }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof HealthEvaluateListener) ((HealthEvaluateListener)listener).enterTandemRight(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof HealthEvaluateListener) ((HealthEvaluateListener)listener).exitTandemRight(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof HealthEvaluateVisitor) return ((HealthEvaluateVisitor<? extends T>)visitor).visitTandemRight(this);
			else return visitor.visitChildren(this);
		}
	}

	public final CalcuContext calcu() throws RecognitionException {
		return calcu(0);
	}

	private CalcuContext calcu(int _p) throws RecognitionException {
		ParserRuleContext _parentctx = _ctx;
		int _parentState = getState();
		CalcuContext _localctx = new CalcuContext(_ctx, _parentState);
		CalcuContext _prevctx = _localctx;
		int _startState = 20;
		enterRecursionRule(_localctx, 20, RULE_calcu, _p);
		int _la;
		try {
			int _alt;
			enterOuterAlt(_localctx, 1);
			{
			setState(187);
			_errHandler.sync(this);
			switch (_input.LA(1)) {
			case LPARENTHESE:
				{
				_localctx = new ParensContext(_localctx);
				_ctx = _localctx;
				_prevctx = _localctx;

				setState(179);
				match(LPARENTHESE);
				setState(180);
				calcu(0);
				setState(181);
				match(RPARENTHESE);
				}
				break;
			case PARAM:
				{
				_localctx = new ParamContext(_localctx);
				_ctx = _localctx;
				_prevctx = _localctx;
				setState(183);
				match(PARAM);
				}
				break;
			case NUMBER:
				{
				_localctx = new NumberContext(_localctx);
				_ctx = _localctx;
				_prevctx = _localctx;
				setState(184);
				match(NUMBER);
				}
				break;
			case XN:
				{
				_localctx = new XnContext(_localctx);
				_ctx = _localctx;
				_prevctx = _localctx;
				setState(185);
				match(XN);
				}
				break;
			case ABS:
				{
				_localctx = new CalcuAbsContext(_localctx);
				_ctx = _localctx;
				_prevctx = _localctx;
				setState(186);
				abs();
				}
				break;
			default:
				throw new NoViableAltException(this);
			}
			_ctx.stop = _input.LT(-1);
			setState(203);
			_errHandler.sync(this);
			_alt = getInterpreter().adaptivePredict(_input,22,_ctx);
			while ( _alt!=2 && _alt!= ATN.INVALID_ALT_NUMBER ) {
				if ( _alt==1 ) {
					if ( _parseListeners!=null ) triggerExitRuleEvent();
					_prevctx = _localctx;
					{
					setState(201);
					_errHandler.sync(this);
					switch ( getInterpreter().adaptivePredict(_input,21,_ctx) ) {
					case 1:
						{
						_localctx = new MulAndDivContext(new CalcuContext(_parentctx, _parentState));
						pushNewRecursionContext(_localctx, _startState, RULE_calcu);
						setState(189);
						if (!(precpred(_ctx, 8))) throw new FailedPredicateException(this, "precpred(_ctx, 8)");
						setState(190);
						((MulAndDivContext)_localctx).opt = _input.LT(1);
						_la = _input.LA(1);
						if ( !(_la==MUL || _la==DIV) ) {
							((MulAndDivContext)_localctx).opt = (Token)_errHandler.recoverInline(this);
						}
						else {
							if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
							_errHandler.reportMatch(this);
							consume();
						}
						setState(191);
						calcu(9);
						}
						break;
					case 2:
						{
						_localctx = new AddAndSubContext(new CalcuContext(_parentctx, _parentState));
						pushNewRecursionContext(_localctx, _startState, RULE_calcu);
						setState(192);
						if (!(precpred(_ctx, 7))) throw new FailedPredicateException(this, "precpred(_ctx, 7)");
						setState(193);
						((AddAndSubContext)_localctx).opt = _input.LT(1);
						_la = _input.LA(1);
						if ( !(_la==ADD || _la==SUB) ) {
							((AddAndSubContext)_localctx).opt = (Token)_errHandler.recoverInline(this);
						}
						else {
							if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
							_errHandler.reportMatch(this);
							consume();
						}
						setState(194);
						calcu(8);
						}
						break;
					case 3:
						{
						_localctx = new TandemLeftContext(new CalcuContext(_parentctx, _parentState));
						pushNewRecursionContext(_localctx, _startState, RULE_calcu);
						setState(195);
						if (!(precpred(_ctx, 6))) throw new FailedPredicateException(this, "precpred(_ctx, 6)");
						setState(196);
						match(LPARENTHESE);
						setState(197);
						calcu(7);
						}
						break;
					case 4:
						{
						_localctx = new TandemRightContext(new CalcuContext(_parentctx, _parentState));
						pushNewRecursionContext(_localctx, _startState, RULE_calcu);
						setState(198);
						if (!(precpred(_ctx, 5))) throw new FailedPredicateException(this, "precpred(_ctx, 5)");
						setState(199);
						match(RPARENTHESE);
						setState(200);
						calcu(6);
						}
						break;
					}
					} 
				}
				setState(205);
				_errHandler.sync(this);
				_alt = getInterpreter().adaptivePredict(_input,22,_ctx);
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			unrollRecursionContexts(_parentctx);
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class AbsContext extends ParserRuleContext {
		public AbsContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_abs; }
	 
		public AbsContext() { }
		public void copyFrom(AbsContext ctx) {
			super.copyFrom(ctx);
		}
	}
	@SuppressWarnings("CheckReturnValue")
	public static class AbsNumberContext extends AbsContext {
		public TerminalNode ABS() { return getToken(HealthEvaluateParser.ABS, 0); }
		public TerminalNode LPARENTHESE() { return getToken(HealthEvaluateParser.LPARENTHESE, 0); }
		public TerminalNode NUMBER() { return getToken(HealthEvaluateParser.NUMBER, 0); }
		public TerminalNode RPARENTHESE() { return getToken(HealthEvaluateParser.RPARENTHESE, 0); }
		public AbsNumberContext(AbsContext ctx) { copyFrom(ctx); }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof HealthEvaluateListener) ((HealthEvaluateListener)listener).enterAbsNumber(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof HealthEvaluateListener) ((HealthEvaluateListener)listener).exitAbsNumber(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof HealthEvaluateVisitor) return ((HealthEvaluateVisitor<? extends T>)visitor).visitAbsNumber(this);
			else return visitor.visitChildren(this);
		}
	}
	@SuppressWarnings("CheckReturnValue")
	public static class AbsCalcuContext extends AbsContext {
		public TerminalNode ABS() { return getToken(HealthEvaluateParser.ABS, 0); }
		public TerminalNode LPARENTHESE() { return getToken(HealthEvaluateParser.LPARENTHESE, 0); }
		public CalcuContext calcu() {
			return getRuleContext(CalcuContext.class,0);
		}
		public TerminalNode RPARENTHESE() { return getToken(HealthEvaluateParser.RPARENTHESE, 0); }
		public AbsCalcuContext(AbsContext ctx) { copyFrom(ctx); }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof HealthEvaluateListener) ((HealthEvaluateListener)listener).enterAbsCalcu(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof HealthEvaluateListener) ((HealthEvaluateListener)listener).exitAbsCalcu(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof HealthEvaluateVisitor) return ((HealthEvaluateVisitor<? extends T>)visitor).visitAbsCalcu(this);
			else return visitor.visitChildren(this);
		}
	}

	public final AbsContext abs() throws RecognitionException {
		AbsContext _localctx = new AbsContext(_ctx, getState());
		enterRule(_localctx, 22, RULE_abs);
		try {
			setState(215);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,23,_ctx) ) {
			case 1:
				_localctx = new AbsNumberContext(_localctx);
				enterOuterAlt(_localctx, 1);
				{
				setState(206);
				match(ABS);
				setState(207);
				match(LPARENTHESE);
				setState(208);
				match(NUMBER);
				setState(209);
				match(RPARENTHESE);
				}
				break;
			case 2:
				_localctx = new AbsCalcuContext(_localctx);
				enterOuterAlt(_localctx, 2);
				{
				setState(210);
				match(ABS);
				setState(211);
				match(LPARENTHESE);
				setState(212);
				calcu(0);
				setState(213);
				match(RPARENTHESE);
				}
				break;
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public boolean sempred(RuleContext _localctx, int ruleIndex, int predIndex) {
		switch (ruleIndex) {
		case 7:
			return compare_sempred((CompareContext)_localctx, predIndex);
		case 10:
			return calcu_sempred((CalcuContext)_localctx, predIndex);
		}
		return true;
	}
	private boolean compare_sempred(CompareContext _localctx, int predIndex) {
		switch (predIndex) {
		case 0:
			return precpred(_ctx, 4);
		case 1:
			return precpred(_ctx, 3);
		}
		return true;
	}
	private boolean calcu_sempred(CalcuContext _localctx, int predIndex) {
		switch (predIndex) {
		case 2:
			return precpred(_ctx, 8);
		case 3:
			return precpred(_ctx, 7);
		case 4:
			return precpred(_ctx, 6);
		case 5:
			return precpred(_ctx, 5);
		}
		return true;
	}

	public static final String _serializedATN =
		"\u0004\u0001\'\u00da\u0002\u0000\u0007\u0000\u0002\u0001\u0007\u0001\u0002"+
		"\u0002\u0007\u0002\u0002\u0003\u0007\u0003\u0002\u0004\u0007\u0004\u0002"+
		"\u0005\u0007\u0005\u0002\u0006\u0007\u0006\u0002\u0007\u0007\u0007\u0002"+
		"\b\u0007\b\u0002\t\u0007\t\u0002\n\u0007\n\u0002\u000b\u0007\u000b\u0001"+
		"\u0000\u0001\u0000\u0001\u0000\u0005\u0000\u001c\b\u0000\n\u0000\f\u0000"+
		"\u001f\t\u0000\u0001\u0000\u0001\u0000\u0005\u0000#\b\u0000\n\u0000\f"+
		"\u0000&\t\u0000\u0001\u0000\u0001\u0000\u0001\u0000\u0001\u0001\u0001"+
		"\u0001\u0005\u0001-\b\u0001\n\u0001\f\u00010\t\u0001\u0001\u0002\u0001"+
		"\u0002\u0001\u0002\u0004\u00025\b\u0002\u000b\u0002\f\u00026\u0001\u0002"+
		"\u0001\u0002\u0001\u0002\u0004\u0002<\b\u0002\u000b\u0002\f\u0002=\u0001"+
		"\u0002\u0004\u0002A\b\u0002\u000b\u0002\f\u0002B\u0001\u0002\u0003\u0002"+
		"F\b\u0002\u0001\u0003\u0001\u0003\u0001\u0003\u0001\u0003\u0001\u0003"+
		"\u0001\u0003\u0001\u0003\u0001\u0003\u0001\u0003\u0005\u0003Q\b\u0003"+
		"\n\u0003\f\u0003T\t\u0003\u0001\u0003\u0001\u0003\u0001\u0003\u0001\u0003"+
		"\u0001\u0003\u0003\u0003[\b\u0003\u0001\u0004\u0001\u0004\u0003\u0004"+
		"_\b\u0004\u0001\u0004\u0001\u0004\u0003\u0004c\b\u0004\u0001\u0005\u0001"+
		"\u0005\u0003\u0005g\b\u0005\u0001\u0005\u0001\u0005\u0003\u0005k\b\u0005"+
		"\u0001\u0006\u0001\u0006\u0001\u0006\u0001\u0006\u0001\u0006\u0001\u0006"+
		"\u0001\u0006\u0001\u0006\u0001\u0006\u0001\u0006\u0001\u0006\u0001\u0006"+
		"\u0003\u0006y\b\u0006\u0001\u0007\u0001\u0007\u0001\u0007\u0003\u0007"+
		"~\b\u0007\u0001\u0007\u0001\u0007\u0001\u0007\u0001\u0007\u0001\u0007"+
		"\u0001\u0007\u0005\u0007\u0086\b\u0007\n\u0007\f\u0007\u0089\t\u0007\u0001"+
		"\b\u0001\b\u0001\b\u0001\b\u0001\b\u0001\b\u0001\b\u0001\b\u0001\b\u0001"+
		"\b\u0001\b\u0001\b\u0001\b\u0001\b\u0001\b\u0001\b\u0001\b\u0001\b\u0001"+
		"\b\u0001\b\u0001\b\u0001\b\u0001\b\u0001\b\u0001\b\u0001\b\u0001\b\u0001"+
		"\b\u0001\b\u0001\b\u0003\b\u00a9\b\b\u0001\t\u0001\t\u0001\t\u0001\t\u0001"+
		"\t\u0001\t\u0003\t\u00b1\b\t\u0001\n\u0001\n\u0001\n\u0001\n\u0001\n\u0001"+
		"\n\u0001\n\u0001\n\u0001\n\u0003\n\u00bc\b\n\u0001\n\u0001\n\u0001\n\u0001"+
		"\n\u0001\n\u0001\n\u0001\n\u0001\n\u0001\n\u0001\n\u0001\n\u0001\n\u0005"+
		"\n\u00ca\b\n\n\n\f\n\u00cd\t\n\u0001\u000b\u0001\u000b\u0001\u000b\u0001"+
		"\u000b\u0001\u000b\u0001\u000b\u0001\u000b\u0001\u000b\u0001\u000b\u0003"+
		"\u000b\u00d8\b\u000b\u0001\u000b\u0001R\u0002\u000e\u0014\f\u0000\u0002"+
		"\u0004\u0006\b\n\f\u000e\u0010\u0012\u0014\u0016\u0000\u0004\u0002\u0000"+
		"\b\b\u0019\u0019\u0001\u0000\t\u000e\u0001\u0000\u0011\u0012\u0001\u0000"+
		"\u0013\u0014\u00f3\u0000\u0018\u0001\u0000\u0000\u0000\u0002.\u0001\u0000"+
		"\u0000\u0000\u0004E\u0001\u0000\u0000\u0000\u0006G\u0001\u0000\u0000\u0000"+
		"\b\\\u0001\u0000\u0000\u0000\nd\u0001\u0000\u0000\u0000\fx\u0001\u0000"+
		"\u0000\u0000\u000e}\u0001\u0000\u0000\u0000\u0010\u00a8\u0001\u0000\u0000"+
		"\u0000\u0012\u00b0\u0001\u0000\u0000\u0000\u0014\u00bb\u0001\u0000\u0000"+
		"\u0000\u0016\u00d7\u0001\u0000\u0000\u0000\u0018\u0019\u0005$\u0000\u0000"+
		"\u0019\u001d\u0005\u001c\u0000\u0000\u001a\u001c\u0005\b\u0000\u0000\u001b"+
		"\u001a\u0001\u0000\u0000\u0000\u001c\u001f\u0001\u0000\u0000\u0000\u001d"+
		"\u001b\u0001\u0000\u0000\u0000\u001d\u001e\u0001\u0000\u0000\u0000\u001e"+
		" \u0001\u0000\u0000\u0000\u001f\u001d\u0001\u0000\u0000\u0000 $\u0003"+
		"\u0002\u0001\u0000!#\u0005\b\u0000\u0000\"!\u0001\u0000\u0000\u0000#&"+
		"\u0001\u0000\u0000\u0000$\"\u0001\u0000\u0000\u0000$%\u0001\u0000\u0000"+
		"\u0000%\'\u0001\u0000\u0000\u0000&$\u0001\u0000\u0000\u0000\'(\u0005\u001d"+
		"\u0000\u0000()\u0005\u0000\u0000\u0001)\u0001\u0001\u0000\u0000\u0000"+
		"*-\u0003\u0004\u0002\u0000+-\u0005\b\u0000\u0000,*\u0001\u0000\u0000\u0000"+
		",+\u0001\u0000\u0000\u0000-0\u0001\u0000\u0000\u0000.,\u0001\u0000\u0000"+
		"\u0000./\u0001\u0000\u0000\u0000/\u0003\u0001\u0000\u0000\u00000.\u0001"+
		"\u0000\u0000\u000012\u0003\u000e\u0007\u000023\u0007\u0000\u0000\u0000"+
		"35\u0001\u0000\u0000\u000041\u0001\u0000\u0000\u000056\u0001\u0000\u0000"+
		"\u000064\u0001\u0000\u0000\u000067\u0001\u0000\u0000\u00007F\u0001\u0000"+
		"\u0000\u000089\u0003\f\u0006\u00009:\u0007\u0000\u0000\u0000:<\u0001\u0000"+
		"\u0000\u0000;8\u0001\u0000\u0000\u0000<=\u0001\u0000\u0000\u0000=;\u0001"+
		"\u0000\u0000\u0000=>\u0001\u0000\u0000\u0000>F\u0001\u0000\u0000\u0000"+
		"?A\u0003\u0006\u0003\u0000@?\u0001\u0000\u0000\u0000AB\u0001\u0000\u0000"+
		"\u0000B@\u0001\u0000\u0000\u0000BC\u0001\u0000\u0000\u0000CF\u0001\u0000"+
		"\u0000\u0000DF\u0003\u0014\n\u0000E4\u0001\u0000\u0000\u0000E;\u0001\u0000"+
		"\u0000\u0000E@\u0001\u0000\u0000\u0000ED\u0001\u0000\u0000\u0000F\u0005"+
		"\u0001\u0000\u0000\u0000GH\u0003\b\u0004\u0000HI\u0005\u001c\u0000\u0000"+
		"IJ\u0003\u0002\u0001\u0000JR\u0005\u001d\u0000\u0000KL\u0003\n\u0005\u0000"+
		"LM\u0005\u001c\u0000\u0000MN\u0003\u0002\u0001\u0000NO\u0005\u001d\u0000"+
		"\u0000OQ\u0001\u0000\u0000\u0000PK\u0001\u0000\u0000\u0000QT\u0001\u0000"+
		"\u0000\u0000RS\u0001\u0000\u0000\u0000RP\u0001\u0000\u0000\u0000SZ\u0001"+
		"\u0000\u0000\u0000TR\u0001\u0000\u0000\u0000UV\u0005\u0018\u0000\u0000"+
		"VW\u0005\u001c\u0000\u0000WX\u0003\u0002\u0001\u0000XY\u0005\u001d\u0000"+
		"\u0000Y[\u0001\u0000\u0000\u0000ZU\u0001\u0000\u0000\u0000Z[\u0001\u0000"+
		"\u0000\u0000[\u0007\u0001\u0000\u0000\u0000\\^\u0005\u0015\u0000\u0000"+
		"]_\u0005\u001e\u0000\u0000^]\u0001\u0000\u0000\u0000^_\u0001\u0000\u0000"+
		"\u0000_`\u0001\u0000\u0000\u0000`b\u0003\u000e\u0007\u0000ac\u0005\u001f"+
		"\u0000\u0000ba\u0001\u0000\u0000\u0000bc\u0001\u0000\u0000\u0000c\t\u0001"+
		"\u0000\u0000\u0000df\u0005\u0016\u0000\u0000eg\u0005\u001e\u0000\u0000"+
		"fe\u0001\u0000\u0000\u0000fg\u0001\u0000\u0000\u0000gh\u0001\u0000\u0000"+
		"\u0000hj\u0003\u000e\u0007\u0000ik\u0005\u001f\u0000\u0000ji\u0001\u0000"+
		"\u0000\u0000jk\u0001\u0000\u0000\u0000k\u000b\u0001\u0000\u0000\u0000"+
		"lm\u0005\u0001\u0000\u0000mn\u0005#\u0000\u0000no\u0005\u0002\u0000\u0000"+
		"oy\u0003\u0014\n\u0000pq\u0005\u0003\u0000\u0000qr\u0005#\u0000\u0000"+
		"rs\u0005\u0002\u0000\u0000sy\u0005\"\u0000\u0000tu\u0005\u0004\u0000\u0000"+
		"uv\u0005#\u0000\u0000vw\u0005\u0002\u0000\u0000wy\u0003\u000e\u0007\u0000"+
		"xl\u0001\u0000\u0000\u0000xp\u0001\u0000\u0000\u0000xt\u0001\u0000\u0000"+
		"\u0000y\r\u0001\u0000\u0000\u0000z{\u0006\u0007\uffff\uffff\u0000{~\u0003"+
		"\u0010\b\u0000|~\u0005 \u0000\u0000}z\u0001\u0000\u0000\u0000}|\u0001"+
		"\u0000\u0000\u0000~\u0087\u0001\u0000\u0000\u0000\u007f\u0080\n\u0004"+
		"\u0000\u0000\u0080\u0081\u0005\u000f\u0000\u0000\u0081\u0086\u0003\u000e"+
		"\u0007\u0005\u0082\u0083\n\u0003\u0000\u0000\u0083\u0084\u0005\u0010\u0000"+
		"\u0000\u0084\u0086\u0003\u000e\u0007\u0004\u0085\u007f\u0001\u0000\u0000"+
		"\u0000\u0085\u0082\u0001\u0000\u0000\u0000\u0086\u0089\u0001\u0000\u0000"+
		"\u0000\u0087\u0085\u0001\u0000\u0000\u0000\u0087\u0088\u0001\u0000\u0000"+
		"\u0000\u0088\u000f\u0001\u0000\u0000\u0000\u0089\u0087\u0001\u0000\u0000"+
		"\u0000\u008a\u008b\u0003\u0012\t\u0000\u008b\u008c\u0007\u0001\u0000\u0000"+
		"\u008c\u008d\u0003\u0012\t\u0000\u008d\u008e\u0007\u0001\u0000\u0000\u008e"+
		"\u008f\u0003\u0012\t\u0000\u008f\u00a9\u0001\u0000\u0000\u0000\u0090\u0091"+
		"\u0003\u0012\t\u0000\u0091\u0092\u0005\t\u0000\u0000\u0092\u0093\u0003"+
		"\u0012\t\u0000\u0093\u00a9\u0001\u0000\u0000\u0000\u0094\u0095\u0003\u0012"+
		"\t\u0000\u0095\u0096\u0005\n\u0000\u0000\u0096\u0097\u0003\u0012\t\u0000"+
		"\u0097\u00a9\u0001\u0000\u0000\u0000\u0098\u0099\u0003\u0012\t\u0000\u0099"+
		"\u009a\u0005\u000b\u0000\u0000\u009a\u009b\u0003\u0012\t\u0000\u009b\u00a9"+
		"\u0001\u0000\u0000\u0000\u009c\u009d\u0003\u0012\t\u0000\u009d\u009e\u0005"+
		"\f\u0000\u0000\u009e\u009f\u0003\u0012\t\u0000\u009f\u00a9\u0001\u0000"+
		"\u0000\u0000\u00a0\u00a1\u0003\u0012\t\u0000\u00a1\u00a2\u0005\r\u0000"+
		"\u0000\u00a2\u00a3\u0003\u0012\t\u0000\u00a3\u00a9\u0001\u0000\u0000\u0000"+
		"\u00a4\u00a5\u0003\u0012\t\u0000\u00a5\u00a6\u0005\u000e\u0000\u0000\u00a6"+
		"\u00a7\u0003\u0012\t\u0000\u00a7\u00a9\u0001\u0000\u0000\u0000\u00a8\u008a"+
		"\u0001\u0000\u0000\u0000\u00a8\u0090\u0001\u0000\u0000\u0000\u00a8\u0094"+
		"\u0001\u0000\u0000\u0000\u00a8\u0098\u0001\u0000\u0000\u0000\u00a8\u009c"+
		"\u0001\u0000\u0000\u0000\u00a8\u00a0\u0001\u0000\u0000\u0000\u00a8\u00a4"+
		"\u0001\u0000\u0000\u0000\u00a9\u0011\u0001\u0000\u0000\u0000\u00aa\u00ab"+
		"\u0005\u001e\u0000\u0000\u00ab\u00ac\u0003\u0010\b\u0000\u00ac\u00ad\u0005"+
		"\u001f\u0000\u0000\u00ad\u00b1\u0001\u0000\u0000\u0000\u00ae\u00b1\u0003"+
		"\u0014\n\u0000\u00af\u00b1\u0005 \u0000\u0000\u00b0\u00aa\u0001\u0000"+
		"\u0000\u0000\u00b0\u00ae\u0001\u0000\u0000\u0000\u00b0\u00af\u0001\u0000"+
		"\u0000\u0000\u00b1\u0013\u0001\u0000\u0000\u0000\u00b2\u00b3\u0006\n\uffff"+
		"\uffff\u0000\u00b3\u00b4\u0005\u001e\u0000\u0000\u00b4\u00b5\u0003\u0014"+
		"\n\u0000\u00b5\u00b6\u0005\u001f\u0000\u0000\u00b6\u00bc\u0001\u0000\u0000"+
		"\u0000\u00b7\u00bc\u0005%\u0000\u0000\u00b8\u00bc\u0005!\u0000\u0000\u00b9"+
		"\u00bc\u0005&\u0000\u0000\u00ba\u00bc\u0003\u0016\u000b\u0000\u00bb\u00b2"+
		"\u0001\u0000\u0000\u0000\u00bb\u00b7\u0001\u0000\u0000\u0000\u00bb\u00b8"+
		"\u0001\u0000\u0000\u0000\u00bb\u00b9\u0001\u0000\u0000\u0000\u00bb\u00ba"+
		"\u0001\u0000\u0000\u0000\u00bc\u00cb\u0001\u0000\u0000\u0000\u00bd\u00be"+
		"\n\b\u0000\u0000\u00be\u00bf\u0007\u0002\u0000\u0000\u00bf\u00ca\u0003"+
		"\u0014\n\t\u00c0\u00c1\n\u0007\u0000\u0000\u00c1\u00c2\u0007\u0003\u0000"+
		"\u0000\u00c2\u00ca\u0003\u0014\n\b\u00c3\u00c4\n\u0006\u0000\u0000\u00c4"+
		"\u00c5\u0005\u001e\u0000\u0000\u00c5\u00ca\u0003\u0014\n\u0007\u00c6\u00c7"+
		"\n\u0005\u0000\u0000\u00c7\u00c8\u0005\u001f\u0000\u0000\u00c8\u00ca\u0003"+
		"\u0014\n\u0006\u00c9\u00bd\u0001\u0000\u0000\u0000\u00c9\u00c0\u0001\u0000"+
		"\u0000\u0000\u00c9\u00c3\u0001\u0000\u0000\u0000\u00c9\u00c6\u0001\u0000"+
		"\u0000\u0000\u00ca\u00cd\u0001\u0000\u0000\u0000\u00cb\u00c9\u0001\u0000"+
		"\u0000\u0000\u00cb\u00cc\u0001\u0000\u0000\u0000\u00cc\u0015\u0001\u0000"+
		"\u0000\u0000\u00cd\u00cb\u0001\u0000\u0000\u0000\u00ce\u00cf\u0005\'\u0000"+
		"\u0000\u00cf\u00d0\u0005\u001e\u0000\u0000\u00d0\u00d1\u0005!\u0000\u0000"+
		"\u00d1\u00d8\u0005\u001f\u0000\u0000\u00d2\u00d3\u0005\'\u0000\u0000\u00d3"+
		"\u00d4\u0005\u001e\u0000\u0000\u00d4\u00d5\u0003\u0014\n\u0000\u00d5\u00d6"+
		"\u0005\u001f\u0000\u0000\u00d6\u00d8\u0001\u0000\u0000\u0000\u00d7\u00ce"+
		"\u0001\u0000\u0000\u0000\u00d7\u00d2\u0001\u0000\u0000\u0000\u00d8\u0017"+
		"\u0001\u0000\u0000\u0000\u0018\u001d$,.6=BERZ^bfjx}\u0085\u0087\u00a8"+
		"\u00b0\u00bb\u00c9\u00cb\u00d7";
	public static final ATN _ATN =
		new ATNDeserializer().deserialize(_serializedATN.toCharArray());
	static {
		_decisionToDFA = new DFA[_ATN.getNumberOfDecisions()];
		for (int i = 0; i < _ATN.getNumberOfDecisions(); i++) {
			_decisionToDFA[i] = new DFA(_ATN.getDecisionState(i), i);
		}
	}
}